home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1995 November / EnigmA AMIGA RUN 02 (1995)(G.R. Edizioni)(IT)[!][issue 1995-11][Skylink CD].iso / earcd / ead / ead17.dms / ead17.adf / Listati / Enough.c < prev    next >
C/C++ Source or Header  |  1989-08-01  |  7KB  |  314 lines
  1. /* ********************************************************************
  2. Programma ...... Enough.c
  3. Versione ....... 1.01i - Luglio 1989
  4. Autore ......... Bruce A. Barret
  5. Software ....... Lattice C V5.02 / Aztec C V5.0a
  6. Hardware ....... Amiga + Kickstart & WB V1.2/1.3
  7. Sintassi ....... ENOUGH [{MEM|FAST|CHIP}| nnn[K] [EXISTS file]
  8.                         DISK drv: fff[K]]   (per file script)
  9. Note ........... Traduzione, debugging ed adattamento di L.Callegari
  10. ********************************************************************* */
  11.  
  12. #include <exec/types.h>
  13. #include <ctype.h>
  14. #include <exec/memory.h>
  15. #include <libraries/dosextens.h>
  16. #include <clib/macros.h>
  17. #include <stdio.h>
  18.  
  19. #ifdef LATTICE
  20. #include <string.h>
  21. #include <proto/dos.h>
  22. #include <proto/exec.h>
  23. #include <stdlib.h>
  24. #else
  25. #include <functions.h>
  26. #endif
  27.  
  28. /* Definizioni di costanti */
  29.  
  30. #define VERNO 1
  31. #define RELNO 0
  32. #define DATE  "13-May-86"
  33. #define AUTHOR    Bruce A. Barrett
  34.  
  35. /*    Motivazioni di termine per cleanup()*/
  36.  
  37. #define    DIE_OK                0
  38. #define    DIE_MEM                1
  39. #define    DIE_NOOUTPUT        2
  40. #define    DIE_BADARGS            3
  41. #define    DIE_S_DIR            4
  42. #define    DIE_D_DIR            5
  43. #define    DIE_S_FILE            6
  44. #define    DIE_D_FILE            7
  45. #define    DIE_FIBOVERFLOW    8
  46. #define    DIE_FIBUNDERFLOW     9
  47. #define    DIE_CTRL_C            10
  48. #define    DIE_NOT_ENOUGH        11
  49. #define MAX_KEYWD_LEN        12
  50.  
  51. /* Per debugging; se necessario porre a TRUE*/
  52. #define FIX FALSE
  53. #if FIX
  54. #define    ROUTINE(foo)    kprintf(foo)    /* debug richiesto */
  55. #else
  56. #define    ROUTINE(foo)    /* negativo */
  57. #endif
  58.  
  59. int        f_lock;
  60. struct    FileInfoBlock *file_info_block;
  61. int        cur_argc;
  62. int        gl_argc;
  63.  
  64. /* Sopprime il requester "Please insert volume" */
  65. APTR suppress_IO_err()
  66. {
  67. struct Process *my_proc;
  68. APTR    old_window;
  69.     
  70. ROUTINE("suppress_IO_err\n");
  71. my_proc = (struct Process *) FindTask("");
  72. old_window = my_proc -> pr_WindowPtr;
  73. my_proc -> pr_WindowPtr = (APTR) -1;
  74. return( old_window );
  75. }
  76.  
  77. /* Permette requester Please insert volume " */
  78.     
  79. void allow_IO_err( old_wind )
  80. APTR    old_wind;
  81. {
  82. struct Process *my_proc;
  83.  
  84. ROUTINE("allow_IO_err\n");
  85. my_proc = (struct Process *)FindTask("");
  86. my_proc -> pr_WindowPtr = old_wind;
  87. }
  88.     
  89. /* Dato un tipo di memoria, ne misura la quantità disponibile */
  90.  
  91. do_mem_type(argv, type)
  92. char    *argv[]; int        type;
  93. {
  94. int        avail, need;
  95.     
  96. ROUTINE("do_mem_type\n" );
  97. if ( cur_argc >= gl_argc )
  98.     return(DIE_BADARGS);
  99.  
  100. avail = AvailMem(type);
  101. sscanf(argv[cur_argc], "%d", &need);
  102. cur_argc++;
  103. if (need == 0)
  104.     return( DIE_BADARGS );
  105. if ( (need*1024) <= avail )
  106.     return( DIE_OK );
  107. else
  108.     return( DIE_NOT_ENOUGH );
  109. }
  110.  
  111. do_mem( argv )
  112. char    *argv[];
  113. {
  114. ROUTINE("do_mem\n");
  115. cur_argc++;
  116. return( do_mem_type(argv, MEMF_LARGEST) );
  117. }
  118.  
  119. do_chip(argv)
  120. char    *argv[];
  121. {
  122. ROUTINE("do_chip\n");
  123. cur_argc++;
  124. return( do_mem_type(argv, MEMF_CHIP|MEMF_LARGEST) );
  125. }
  126.  
  127. do_fast(argv)
  128. char    *argv[];
  129. {
  130. ROUTINE("do_fast\n");
  131. cur_argc++;
  132. return( do_mem_type( argv, MEMF_FAST|MEMF_LARGEST) );
  133. }
  134.  
  135. do_disk(argv)
  136. char    *argv[];
  137. {                        /* do_disk */
  138. int        need, ret_val;
  139. LONG    my_lock, free;
  140. BOOL    result;
  141. APTR    old_ptr;
  142. struct InfoData *info_data;
  143.     
  144. ROUTINE("do_disk\n");
  145. info_data = 0;            /* Rimuove warning del Lattice */
  146. cur_argc++;                /* Salta keyword DISK */
  147. ret_val = DIE_NOT_ENOUGH;
  148.  
  149. /* Verifica il numero di argomenti sulla linea di comandi */
  150. if ((cur_argc+1) >= gl_argc)
  151.     return(DIE_BADARGS);
  152.  
  153. /* verifica l'esistenza del volume o del drive */
  154. old_ptr = (APTR) suppress_IO_err();    /* Disabilita requester */
  155. my_lock = Lock(argv[cur_argc], MODE_OLDFILE);
  156. allow_IO_err(old_ptr);                    /* Riabilita i requester */
  157. cur_argc++;
  158. if ( my_lock == 0 ) return( ret_val );
  159.  
  160. /* Legge informazioni sul volume */
  161. info_data = (struct InfoData *) AllocMem(sizeof(*info_data), 0);
  162. if (info_data == 0)
  163.     {
  164.     UnLock(my_lock);
  165.     return(ret_val);
  166. }
  167.  
  168. result = Info(my_lock, info_data);
  169. if (!result)
  170. {
  171.     UnLock(my_lock);
  172.     FreeMem(info_data, sizeof(*info_data));
  173.     return(ret_val);
  174. }
  175.     
  176. /* Legge l'ammontare di spazio sul disco necessario */
  177.  
  178. sscanf(argv[cur_argc], "%d", &need);
  179. cur_argc++;
  180. if (need == 0)
  181.     {
  182.     UnLock(my_lock);
  183.     FreeMem(info_data, sizeof(*info_data));
  184.     return(DIE_BADARGS);
  185.     }
  186. free = (info_data->id_NumBlocks - info_data->id_NumBlocksUsed) *
  187. info_data -> id_BytesPerBlock;
  188.  
  189. UnLock(my_lock);
  190. FreeMem(info_data, sizeof(*info_data));
  191. if (free > (need*1024) ) ret_val = DIE_OK;
  192.     return(ret_val); 
  193. }
  194.  
  195. do_exists(argv)
  196. char    *argv[];
  197. {
  198.     LONG    my_lock;
  199.     APTR    old_ptr;
  200.  
  201.     ROUTINE("do_exists\n");
  202.     cur_argc++;
  203.     old_ptr = (APTR) suppress_IO_err();    /* Disabilita requester */
  204.     if (cur_argc >= gl_argc)
  205.         return(DIE_BADARGS);
  206.     my_lock = Lock( argv[cur_argc], MODE_OLDFILE );
  207.     allow_IO_err( old_ptr );
  208.     cur_argc++;
  209.     if ( my_lock == 0 )
  210.         return( DIE_NOT_ENOUGH );
  211.     UnLock( my_lock );
  212.     return( DIE_OK );
  213. }
  214.  
  215. /* Copia stringa trasformandola in maiuscolo */
  216. void uc_copy(to, from)
  217. char    *to,    *from;
  218. {
  219. ROUTINE("uc_copy\n");
  220. while ( *to++ = toupper(*from++) )
  221.     ;
  222. }
  223.  
  224. /* Verifica pressione di CTRL-C e chiama eventualmente cleanup() */
  225. void testbreak(argv)
  226. char    *argv[];
  227. {
  228. void cleanup();
  229. LONG    newsigs,    oldsigs;
  230.     
  231. ROUTINE("testbreak\n");
  232. newsigs = 0;
  233.    
  234. oldsigs = SetSignal( newsigs, SIGBREAKF_CTRL_C );
  235. if (oldsigs & (SIGBREAKF_CTRL_C) )
  236.     cleanup(argv, DIE_CTRL_C);
  237. }
  238.  
  239. void cleanup( argv, cause )
  240. int    cause;    char    *argv[];
  241. {
  242. ROUTINE("cleanup\n");
  243.  
  244.     switch (cause)
  245.     {
  246.         case DIE_OK:    
  247.         case DIE_MEM:    
  248.         case DIE_NOOUTPUT:
  249.         case DIE_S_DIR:
  250.         case DIE_D_DIR:    
  251.         case DIE_S_FILE:
  252.         case DIE_D_FILE:    
  253.         case DIE_FIBOVERFLOW:    
  254.         case DIE_FIBUNDERFLOW:
  255.         case DIE_NOT_ENOUGH:
  256.         break;
  257.         case DIE_BADARGS:
  258.         printf("Errore: Sintassi del comando scorretta!\n");
  259.         printf("Sintassi: ENOUGH [{MEM|FAST|CHIP} nnn[K]] [EXISTS file\n");
  260.         printf("                 [DISK drv: fff[K]]\n");
  261.         printf("nnn è il numero di K RAM richieste, fff è il nome di K\n");
  262.         printf("sul disco \"drv:\" richiesto, file è il numero di path\n");
  263.         printf("del quale si desidera verificare l'esistenza.\n");
  264.         break;
  265.     case DIE_CTRL_C:
  266.         printf("*BREAK* Fermato dall'utente.\n");
  267.         break;
  268.     }
  269.         ROUTINE("exit\n");
  270.         if (cause == DIE_OK)
  271.             exit( 0L );
  272.         else if (cause == DIE_BADARGS)
  273.             exit( 20L );    /* Errore sintattico! */
  274.         else
  275.             exit( 5L );
  276.     
  277. }
  278.  
  279. void main( argc, argv )
  280. int argc; char *argv[];
  281. {
  282. char        key_wd[MAX_KEYWD_LEN];
  283. int        ret_val;
  284.  
  285. ROUTINE("main\n");
  286. gl_argc = argc;
  287.  
  288. ret_val = DIE_OK;
  289. cur_argc = 1;
  290. while ( (cur_argc < argc) && (ret_val == DIE_OK))
  291.     {
  292. testbreak();
  293. uc_copy(key_wd, argv[cur_argc]);
  294.  
  295.     if (0 == strcmp(&key_wd[0],"MEM"))
  296.         ret_val = do_mem(argv);
  297.     else if (0 == strcmp(&key_wd[0],"CHIP"))
  298.         ret_val = do_chip(argv);
  299.     else if (0 == strcmp(&key_wd[0],"FAST"))
  300.         ret_val = do_fast(argv);
  301.  
  302.     else if (0 == strcmp(&key_wd[0],"DISK"))
  303.         ret_val = do_disk(argv);
  304.     else if (0 == strcmp(&key_wd[0],"EXISTS"))
  305.         ret_val = do_exists(argv);
  306.     else 
  307.         {
  308.         ret_val = DIE_BADARGS;
  309.         printf("%s: Version %ld.%ld, %s\n", argv[0], VERNO, RELNO, DATE);
  310.         }
  311.     }
  312. cleanup(argv, ret_val);
  313. }
  314.